home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 49 / Amiga Format CD49 (2000-01-17)(Future Publishing)(GB)(Track 1 of 3)[!][issue 2000-02].iso / -serious- / programming / mui / mcc_popph / mcc_popph_src / popph.c < prev    next >
C/C++ Source or Header  |  1999-11-30  |  31KB  |  1,063 lines
  1.  
  2. /*
  3. ** $Id: popph.c,v 1.3 1999/11/16 20:58:11 carlos Exp $
  4. **
  5. ** If your editor supports folding, set /// as  the
  6. ** opening and //| as closing phrases.
  7. **
  8. ** © 1999 Marcin Orlowski <carlos@amiga.com.pl>
  9. */
  10.  
  11.  
  12. #include "popph.h"
  13.  
  14.  
  15. #define CLASS       MUIC_Popplaceholder
  16. #define SUPERCLASS  MUIC_Group
  17.  
  18.  
  19. #define UserLibID VERSTAG " © 1999 Marcin Orlowski <carlos@amiga.com.pl>"
  20. #define MASTERVERSION 14
  21.  
  22.  
  23. #define __NAME "Popph"
  24. #define  MCC_USES_IFFPARSE
  25. #include <mui/mccheader.c>
  26. #undef  __NAME
  27.  
  28.  
  29. #define __NAME "Popph"
  30.  
  31. #define list_format_single "P=\033l"
  32. #define list_format_multi  "P=\033r BAR,"
  33.  
  34.  
  35. /// HOOK: WindowHook
  36.  
  37. void __saveds __asm WindowFunc(register __a0 struct Hook *hook, register __a2 Object *popobject, register __a1 Object *window)
  38. {
  39. struct Data *data = hook->h_Data;
  40.  
  41.     set( window, MUIA_Window_ActiveObject, data->lv );
  42.  
  43. }
  44.  
  45. //|
  46. /// HOOK: ObjStrHook
  47.  
  48. void * __saveds __asm ObjStrFunc( register __a0 struct Hook *hook,
  49.                                   register __a2 Object *list,
  50.                                   register __a1 Object *str )
  51. {
  52. struct Data *data = hook->h_Data;
  53.  
  54. char *list_entry;
  55. char *current_string;
  56. char *buffer;
  57. char key[ POPPH_MAX_KEY_LEN ];
  58.  
  59.  
  60.     if( !data->str )
  61.        return( 0 );
  62.  
  63.  
  64.     DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &list_entry);
  65.  
  66.     if( list_entry )
  67.        {
  68.        char *zero;
  69.        int keylen;
  70.        int stringlen;
  71.        int pos;
  72.  
  73.  
  74.        zero = _strchr( list_entry, data->separator );
  75.  
  76.        if( zero )
  77.           keylen = _strlen( list_entry, data->separator );
  78.        else
  79.           keylen = _strlen( list_entry, '\0' );
  80.  
  81.  
  82.        D(bug( "ObjStrFunc: KeyLen: %ld\n", keylen ));
  83.  
  84.        keylen = (keylen > POPPH_MAX_KEY_LEN) ? (POPPH_MAX_KEY_LEN - 1) : keylen ;
  85.  
  86.        CopyMem( list_entry, key, keylen );
  87.        key[ keylen ] = 0;
  88.  
  89.        if( data->replacemode )
  90.            {
  91.            set( data->str, MUIA_Popph_Contents, key );
  92.            }
  93.        else
  94.            {
  95.            get( data->str, MUIA_Popph_BufferPos, &pos );
  96.            get( data->str, MUIA_Popph_Contents, ¤t_string );
  97.            stringlen = _strlen( current_string, 0 );
  98.  
  99.            D(bug( "ObjStrFunc: BufferPos: %ld\n", pos ));
  100.            D(bug( "ObjStrFunc: AllocVec( %ld+%ld+5 bytes )\n", keylen, stringlen ));
  101.  
  102.            if( buffer = AllocVec( keylen + stringlen + 5, MEMF_CLEAR ) )
  103.                {
  104.                CopyMem( current_string, buffer, pos );
  105.                CopyMem( key, buffer + pos, keylen );
  106.                CopyMem( current_string + pos, buffer + pos + keylen, stringlen - pos );
  107.  
  108.                set( data->str, MUIA_Popph_Contents, buffer );
  109.                set( data->str, MUIA_Popph_BufferPos, pos + keylen );
  110. //               set( xget( data->str, MUIA_Window ), MUIA_Window_ActiveObject, data->str );
  111.  
  112. //               DoMethod(_app(data->str), MUIM_Application_PushMethod,
  113. //               _win(data->str), 3, MUIM_Set, MUIA_Window_ActiveObject, data->str);
  114.  
  115.                FreeVec( buffer );
  116.                }
  117.            else
  118.                {
  119.                DisplayBeep(0);
  120.                }
  121.            }
  122.        }
  123.  
  124.        return( 0 );
  125. }
  126.  
  127. //|
  128. /// HOOK: DisplayHook
  129. void * __saveds __asm DisplayFunc(register __a0 struct Hook *hook, register __a2 char **array, register __a1 char *node)
  130. {
  131. static char key[ POPPH_MAX_KEY_LEN ];
  132. static char *info;
  133.  
  134. struct Data *data = hook->h_Data;
  135.  
  136.  
  137.    if( node )
  138.      {
  139.      char *zero = _strchr(node, data->separator);
  140.  
  141.      if( zero )
  142.        {
  143.        CopyMem(node, key, zero-node);
  144.        key[zero-node] = 0;
  145.        info = zero+1;
  146.  
  147. //              D(bug("'%s', '%s'\n", key, info));
  148.        *array++ = key;
  149.        *array++ = info;
  150.        }
  151.      else
  152.        {
  153. //       CopyMem( (char *)"!ERROR", key, 6+1);
  154. //       key[0] = node;
  155. //       info = NULL;
  156.  
  157.        *array++ = node;
  158.        *array++ = NULL;
  159.        }
  160.      }
  161.    else
  162.      {
  163. //     D(bug( "Hook: '%s'  '%s'\n", data->title1, data->title2 ));
  164.      *array++ = data->title1;
  165.      *array++ = data->title2;
  166.      }
  167.  
  168.  
  169.    return(0);
  170. }
  171. //|
  172.  
  173. /// _OpenAsl
  174. ULONG _OpenAsl(struct IClass *cl, Object *obj, struct opSet *msg)
  175. {
  176. struct Data *data = INST_DATA(cl,obj);
  177.  
  178.  
  179. Object *app = (Object *)xget( obj, MUIA_ApplicationObject );
  180. struct Window *win;
  181. APTR   req = data->asl_req;
  182. ULONG  res=NULL;
  183.  
  184. char buf[ POPPH_MAX_STRING_LEN * 2 ];
  185. char *path;
  186. char *path_part;
  187.  
  188.  
  189.     set( app, MUIA_Application_Sleep, TRUE );
  190.     get( obj, MUIA_Window, &win );      
  191.  
  192.     path = (char *)xget( obj, MUIA_Popph_Contents );
  193.     path_part = PathPart( path );
  194.     CopyMem( path, buf, path_part - path );
  195.     buf[ path_part - path ] = 0;
  196.  
  197.  
  198.     if(MUI_AslRequestTags( req,
  199.              ASLFR_Window         , win,
  200.              ASLFR_InitialFile    , FilePart( path ),
  201.              ASLFR_InitialDrawer  , buf,
  202.              TAG_DONE))
  203.                {
  204.                switch( data->asl_type )
  205.                    {
  206. //                   case ASL_FontRequest:
  207. //                   case ASL_ScreenModeRequest:
  208.                    case ASL_FileRequest:
  209.                        {
  210.                        struct FileRequester *freq = req;
  211.  
  212. //                       if(*freq->fr_File)
  213.                            {
  214.                            res = (ULONG)buf;
  215.                            stccpy(buf , freq->fr_Drawer, sizeof( buf ));
  216.                            AddPart(buf, freq->fr_File  , sizeof( buf ));
  217.  
  218.                            set( obj, MUIA_Popph_Contents, buf );
  219.                            }
  220.                        }
  221.                        break;
  222.                    }
  223.                }
  224.  
  225.     set( app, MUIA_Application_Sleep, FALSE );
  226.  
  227.  
  228.     return( res );
  229.  
  230.  
  231. }
  232. //|
  233.  
  234. /// OM_NEW
  235.  
  236.  
  237. ULONG ASM _New(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  238. {
  239. struct Data *data;
  240.  
  241. Object *group, *popobj, *popbutton, *string;
  242. Object *lv, *list;
  243. int    strmaxlen;
  244.  
  245. ULONG  tag_contents = MUIA_String_Contents;
  246. ULONG  tag_bufpos   = MUIA_String_BufferPos;
  247. ULONG  tag_maxlen   = MUIA_String_MaxLen;
  248.  
  249. struct MUI_CustomClass *CL_String = NULL;
  250. char   *string_class = MUIC_String;
  251. char   string_type   = MUIV_Popph_StringType_String;
  252. char   use_our_string_class = FALSE;
  253.  
  254. Object *popaslbutton = NULL;
  255. ULONG  use_asl = FALSE;
  256. APTR   asl_req = NULL;
  257. ULONG  asl_type;
  258.  
  259. ULONG  avoid;
  260.  
  261.  
  262.     D(bug(__NAME ": OM_NEW\n"));
  263.  
  264.  
  265.     // let's discover some initial settings...
  266.  
  267.     string    = (Object *)GetTagData( MUIA_Popph_StringObject, NULL, ((struct opSet *)msg)->ops_AttrList );
  268.     avoid     = GetTagData( MUIA_Popph_Avoid , 0    , ((struct opSet *)msg)->ops_AttrList );
  269.     use_asl   = GetTagData( MUIA_Popph_PopAsl, FALSE, ((struct opSet *)msg)->ops_AttrList );
  270.  
  271.  
  272.     if( ! (strmaxlen = GetTagData( MUIA_String_MaxLen, 0,  ((struct opSet *)msg)->ops_AttrList )) )
  273.        strmaxlen = GetTagData( MUIA_Popph_StringMaxLen, 0,  ((struct opSet *)msg)->ops_AttrList );
  274.  
  275.     if( strmaxlen == 0 )
  276.        strmaxlen = POPPH_MAX_STRING_LEN + (POPPH_MAX_STRING_LEN * use_asl );
  277.  
  278.  
  279.     D(bug(__NAME ": CustomStringObj: %lx (maxlen: %ld)\n", string, strmaxlen ));
  280.  
  281.  
  282.     // let's try which string objects we can use...
  283.  
  284.     D(bug(__NAME ": _Avoid_: %lx\n", avoid, ));
  285.  
  286.     if( (!string) && (!(avoid & MUIV_Popph_Avoid_Textinput )) )
  287.        {
  288.        if( (string = TextinputObject, End ) )
  289.          {
  290.          string_class = MUIC_Textinput;
  291.          tag_contents = MUIA_Textinput_Contents;
  292.          tag_bufpos   = MUIA_Textinput_CursorPos;
  293.          tag_maxlen   = MUIA_Textinput_MaxLen;
  294.          string_type  = MUIV_Popph_StringType_Textinput;
  295.  
  296.          use_our_string_class = TRUE;
  297.          }
  298.        }
  299.  
  300.     if( ( (!string) && (!(avoid & MUIV_Popph_Avoid_Betterstring)) ) )
  301.        {
  302.        if( (string = BetterStringObject, End) )
  303.            {
  304.            string_class = MUIC_BetterString;
  305.            string_type  = MUIV_Popph_StringType_Betterstring;
  306.  
  307.            use_our_string_class = TRUE;
  308.            }
  309.        }
  310.  
  311.     if( !string )
  312.        {
  313.        string = StringObject, End;
  314.  
  315.        string_type  = MUIV_Popph_StringType_String;
  316.        use_our_string_class = TRUE;
  317.        }
  318.  
  319.  
  320.     D(bug(__NAME ": String: %08lx ('%s'), OurClass: %s\n", string, string_class, use_our_string_class ? "Yes" : "No"));
  321.  
  322.     if( use_our_string_class && string )
  323.        {
  324.        if( string )
  325.           {
  326.           MUI_DisposeObject( string );
  327.           }
  328.        else
  329.           {
  330.           D(bug(__NAME ": No string object class available!?\n"));
  331.           return( 0 );
  332.           }
  333.        }
  334.  
  335.  
  336.  
  337.     // let's create string subclass...
  338.  
  339.     if( use_our_string_class )
  340.        {
  341.        if( !(CL_String = MUI_CreateCustomClass(NULL, string_class, NULL, sizeof(struct PPHS_Data), PPHS_Dispatcher)) )
  342.           {
  343.           D(bug(__NAME ": Can't create '%s' custom class\n", string_class ));
  344.           return( NULL );
  345.           }
  346.  
  347.        D(bug(__NAME ": CustomClass created: %lx (%s)\n", CL_String, string_class));
  348.        }
  349.  
  350.  
  351.  
  352.     // shall it be popph/popasl combined object?
  353.  
  354. /*
  355. ASL_FileRequest
  356. ASL_FontRequest
  357. ASL_ScreenModeRequest
  358. */
  359.  
  360.     D(bug(__NAME ": UseASL: %s\n", use_asl ? "Yes" : "No" ));
  361.  
  362.     if( use_asl )
  363.        {
  364.        ULONG asl_drawers;
  365.  
  366. //       if( ! (asl_type = GetTagData( MUIA_Popasl_Type, ASL_FileRequest, ((struct opSet *)msg)->ops_AttrList )) )
  367.          asl_type = GetTagData( MUIA_Popph_AslType, ASL_FileRequest, ((struct opSet *)msg)->ops_AttrList );
  368.  
  369.        asl_drawers = GetTagData( ASLFR_DrawersOnly, FALSE, ((struct opSet *)msg)->ops_AttrList );
  370.        popaslbutton = MUI_MakeObject( MUIO_PopButton, asl_drawers ? MUII_PopDrawer : MUII_PopFile );
  371.  
  372.        if( !popaslbutton )
  373.            {
  374.            D(bug(__NAME ": Cant create popaslbutton!\n"));
  375.            goto cleanup;
  376.            }
  377. /*
  378.        else
  379.            {
  380.            set( popaslbutton, MUIA_CycleChain, TRUE );
  381. //           set( popaslbutton, MUIA_ControlChar, ParseHotKey(key));
  382.            }
  383. */
  384.  
  385.  
  386.        if( !(asl_req = MUI_AllocAslRequestTags( asl_type, TAG_MORE, ((struct opSet *)msg)->ops_AttrList )))
  387.            {
  388.            D(bug(__NAME ": Cant allocate asl request!\n"));
  389.            goto cleanup;
  390.            }
  391.  
  392.        D(bug(__NAME ": AslReq: %lx\n", asl_req ));
  393.        }
  394.  
  395.  
  396.     // let's create Popph object...
  397.  
  398.     if( use_our_string_class )
  399.        {
  400.        if( !(string = NewObject( CL_String->mcc_Class, NULL, StringFrame,
  401.                      MUIA_Popph_StringMaxLen, strmaxlen,
  402.                      MUIA_CycleChain, TRUE,
  403.                      MUIA_Dropable  , TRUE,
  404.                      MUIA_String_AdvanceOnCR, TRUE,
  405.                      MUIA_Popph_StringType, string_type, TAG_DONE )) )
  406.            {
  407.            D(bug(__NAME ": Cant create string object!\n"));
  408.            goto cleanup;
  409.            }
  410.  
  411.        D(bug(__NAME ": CustomStringObject created: %lx\n", string ));
  412.        }
  413.  
  414.  
  415.     obj = (Object *)DoSuperNew(cl, obj,
  416.  
  417.            MUIA_Group_Horiz, TRUE,
  418.  
  419.            Child, group = HGroup,
  420.                   MUIA_Group_Spacing, 0,
  421.  
  422.                   Child, popobj = PopobjectObject,
  423.                          MUIA_Popstring_String, string,
  424.  
  425.                          MUIA_Popstring_Button, popbutton = PopButton(MUII_PopUp),
  426.                          MUIA_Popobject_Object, lv = ListviewObject,
  427.                                     MUIA_CycleChain, TRUE,
  428.                                     MUIA_Listview_DragType, MUIV_Listview_DragType_Immediate,
  429.                                     MUIA_Listview_List, list = ListObject,
  430.                                          InputListFrame,
  431.                                          MUIA_List_Format, list_format_multi,
  432.                                          End,
  433.                                     End,
  434.                          End,
  435.                   End,
  436.  
  437.            TAG_DONE);
  438.  
  439.  
  440.     if( !obj )
  441.        {
  442.        D(bug(__NAME ": Class object creation failed!\n"));
  443.        goto cleanup;
  444.        }
  445.  
  446.  
  447.     if( use_asl )
  448.        DoMethod( group, OM_ADDMEMBER, popaslbutton );
  449.  
  450.  
  451.     /*** init data ***/
  452.     data = INST_DATA(cl, obj);
  453.  
  454.  
  455.     data->CL_String    = CL_String;
  456.  
  457.     data->lv           = lv;
  458.     data->str          = string;
  459.  
  460.  
  461.     D(bug("%lx\n", string ));
  462.  
  463.     data->popbutton    = popbutton;
  464.     data->popaslbutton = popaslbutton;
  465.     data->popobj       = popobj;
  466.  
  467.     data->separator    = '|';
  468.     data->copyentries  = FALSE;
  469.     data->replacemode  = FALSE;
  470.     data->singlecolumn = FALSE;
  471.  
  472.     data->asl_active   = FALSE;
  473.     data->asl_req      = asl_req;
  474.     data->asl_type     = asl_type;
  475.  
  476.     data->title1[0]    = 0;
  477.     data->title2[0]    = 0;
  478.  
  479.  
  480.  
  481.     // only this object is allowed to drop anything...
  482.  
  483.     set( string, MUIA_Popph_DropObject, list );
  484.  
  485. //    set(popbutton, MUIA_CycleChain, TRUE);
  486.  
  487.     data->DisplayHook.h_Data  = (APTR)data;
  488.     data->DisplayHook.h_Entry = (VOID *)DisplayFunc;
  489.     set(lv, MUIA_List_DisplayHook, &data->DisplayHook );
  490.  
  491.     data->ObjStrHook.h_Data  = (APTR)data;
  492.     data->ObjStrHook.h_Entry = (VOID *)ObjStrFunc;
  493.     set(popobj, MUIA_Popobject_ObjStrHook, &data->ObjStrHook );
  494.  
  495.     data->WindowHook.h_Data  = (APTR)data;
  496.     data->WindowHook.h_Entry = (VOID *)WindowFunc;
  497.     set(popobj, MUIA_Popobject_WindowHook, &data->WindowHook );
  498.  
  499.     DoMethod(lv, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  500.        popobj, 2, MUIM_Popstring_Close, TRUE);
  501.  
  502.     if( use_asl )
  503.         {
  504.         DoMethod( popaslbutton, MUIM_Notify, MUIA_Pressed, FALSE,
  505.           obj, 1, MUIM_Popph_OpenAsl );
  506.         }
  507.  
  508.  
  509.     /*** trick to set arguments ***/
  510.     msg->MethodID = OM_SET;
  511.     DoMethodA(obj, (Msg)msg);
  512.     msg->MethodID = OM_NEW;
  513.  
  514.     return((ULONG)obj);
  515.  
  516.  
  517.  
  518. cleanup:
  519.  
  520.     D(bug(__NAME ": OM_NEW: cleanup called\n"));
  521.  
  522.     if( asl_req )
  523.        MUI_FreeAslRequest( asl_req );
  524.  
  525.     if( string )
  526.        MUI_DisposeObject( string );
  527.     if( CL_String )
  528.        MUI_DeleteCustomClass( CL_String );
  529.  
  530.     if( popaslbutton )
  531.        MUI_DisposeObject( popaslbutton );
  532.  
  533.  
  534.     return( NULL );
  535.  
  536. }
  537. //|
  538. /// OM_DISPOSE
  539. ULONG _Dispose(struct IClass *cl, Object *obj, struct opSet *msg)
  540. {
  541. struct Data *data = INST_DATA(cl,obj);
  542.  
  543.  
  544.     D(bug(__NAME ": OM_DISPOSE\n"));
  545.  
  546.  
  547. //    DoMethod( data->popobj, MUIM_Popstring_Close, TRUE );
  548.  
  549.  
  550. /*
  551.     if( data->string )
  552.        {
  553.        MUI_DisposeObject( data->string );
  554.  
  555.        data->string = NULL;
  556.        }
  557.  
  558. */
  559.  
  560. /*
  561.     D(bug(__NAME ": data->popaslbutton: %lx\n", data->popaslbutton ));
  562.     if( data->popaslbutton )
  563.        {
  564.        MUI_DisposeObject( data->popaslbutton );
  565.        data->popaslbutton = NULL;
  566.        }
  567. */
  568.  
  569.     D(bug(__NAME ": data->asl_req: %lx\n", data->asl_req ));
  570.     if( data->asl_req )
  571.        {
  572.        MUI_FreeAslRequest( data->asl_req );
  573.        data->asl_req = NULL;
  574.        }
  575.  
  576.  
  577. //    D(bug(__NAME ":  >> Dispose (SuperClass)\n"));
  578.  
  579.  
  580.     DoSuperMethodA(cl, obj, msg);
  581. //    return(DoSuperMethodA(cl, obj, msg));
  582.  
  583.  
  584.     D(bug(__NAME ": data->CL_String: %lx\n", data->CL_String ));
  585.     if( data->CL_String )
  586.        {
  587.        MUI_DeleteCustomClass( data->CL_String );
  588.        data->CL_String = NULL;
  589.        }
  590.  
  591.     return( 0 );
  592. }
  593. //|
  594. /// OM_SET
  595.  
  596. ULONG ASM _Set(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  597. {
  598. struct Data *data = INST_DATA(cl,obj);
  599. struct TagItem *tags,*tag;
  600.  
  601.     for(tags=((struct opSet *)msg)->ops_AttrList; tag=NextTagItem(&tags); )
  602.        {
  603.        switch(tag->ti_Tag)
  604.           {
  605. ///         case MUIA_String_...:
  606.           case MUIA_String_Accept:
  607.           case MUIA_String_Acknowledge:
  608.           case MUIA_String_AdvanceOnCR:
  609.           case MUIA_String_AttachedList:
  610.           case MUIA_String_BufferPos:
  611.           case MUIA_String_DisplayPos:
  612.           case MUIA_String_EditHook:
  613.           case MUIA_String_Format:
  614.           case MUIA_String_Integer:
  615.           case MUIA_String_LonelyEditHook:
  616.           case MUIA_String_MaxLen:
  617.           case MUIA_String_Reject:
  618.           case MUIA_String_Secret:
  619. //|
  620. ///         case MUIA_Textinput_...:
  621.           case MUIA_Textinput_Multiline:
  622.           case MUIA_Textinput_MaxLen:
  623.           case MUIA_Textinput_MaxLines:
  624.           case MUIA_Textinput_AutoExpand:
  625.           case MUIA_Textinput_LeftOffset:
  626.           case MUIA_Textinput_TopOffset:
  627.           case MUIA_Textinput_TSCO:
  628.           case MUIA_Textinput_Blinkrate:
  629.           case MUIA_Textinput_Cursorstyle:
  630.           case MUIA_Textinput_AdvanceOnCR:
  631.           case MUIA_Textinput_TmpExtension:
  632.           case MUIA_Textinput_Quiet:
  633.           case MUIA_Textinput_Acknowledge:
  634.           case MUIA_Textinput_Integer:
  635.           case MUIA_Textinput_MinVersion:
  636.           case MUIA_Textinput_DefKeys:
  637.           case MUIA_Textinput_DefaultPopup:
  638.           case MUIA_Textinput_WordWrap:
  639.           case MUIA_Textinput_IsNumeric:
  640.           case MUIA_Textinput_MinVal:
  641.           case MUIA_Textinput_MaxVal:
  642.           case MUIA_Textinput_AcceptChars:
  643.           case MUIA_Textinput_RejectChars:
  644.           case MUIA_Textinput_Changed:
  645.           case MUIA_Textinput_AttachedList:
  646.           case MUIA_Textinput_RemainActive:
  647.           case MUIA_Textinput_CursorPos:
  648.           case MUIA_Textinput_Secret:
  649.           case MUIA_Textinput_Lines:
  650.           case MUIA_Textinput_Editable:
  651.           case MUIA_Textinputscroll_UseWinBorder:
  652.           case MUIA_Textinput_IsOld:
  653.           case MUIA_Textinput_MarkStart:
  654.           case MUIA_Textinput_MarkEnd:
  655.           case MUIA_Textinputscroll_VertScrollerOnly:
  656.           case MUIA_Textinput_NoInput:
  657.           case MUIA_Textinput_SetMin:
  658.           case MUIA_Textinput_SetMax:
  659.           case MUIA_Textinput_SetVMax:
  660.           case MUIA_Textinput_Styles:
  661.           case MUIA_Textinput_PreParse:
  662.           case MUIA_Textinput_Format:
  663.           case MUIA_Textinput_SetVMin:
  664.           case MUIA_Textinput_HandleURLHook:
  665.           case MUIA_Textinput_Tabs:
  666.           case MUIA_Textinput_TabLen:
  667.           case MUIA_Textinput_Bookmark1:
  668.           case MUIA_Textinput_Bookmark2:
  669.           case MUIA_Textinput_Bookmark3:
  670.           case MUIA_Textinput_CursorSize:
  671.           case MUIA_Textinput_TopLine:
  672. //|
  673. ///         case MUIA_BetterString_...:
  674.           case MUIA_BetterString_SelectSize:
  675.           case MUIA_BetterString_StayActive:
  676.           case MUIA_BetterString_Columns:
  677. //|
  678.           case MUIA_Popph_ContextMenu:
  679.                set( data->str, tag->ti_Tag, tag->ti_Data );
  680.                break;
  681.  
  682. ///         case MUIA_List_...:
  683.           case MUIA_List_Active:
  684.           case MUIA_List_AdjustHeight:
  685.           case MUIA_List_AdjustWidth:
  686.           case MUIA_List_AutoVisible:
  687.           case MUIA_List_CompareHook:
  688.           case MUIA_List_ConstructHook:
  689.           case MUIA_List_DestructHook:
  690.           case MUIA_List_DisplayHook:
  691.           case MUIA_List_DragSortable:
  692.           case MUIA_List_DropMark:
  693.           case MUIA_List_Entries:
  694.           case MUIA_List_First:
  695.           case MUIA_List_Format:
  696.           case MUIA_List_InsertPosition:
  697.           case MUIA_List_MinLineHeight:
  698.           case MUIA_List_MultiTestHook:
  699.           case MUIA_List_Pool:
  700.           case MUIA_List_PoolPuddleSize:
  701.           case MUIA_List_PoolThreshSize:
  702.           case MUIA_List_Quiet:
  703.           case MUIA_List_ShowDropMarks:
  704.           case MUIA_List_SourceArray:
  705.           case MUIA_List_Title:
  706.           case MUIA_List_Visible:
  707. //|
  708. ///         case MUIA_Listview_...:
  709.           case MUIA_Listview_ClickColumn:
  710.           case MUIA_Listview_DefClickColumn:
  711.           case MUIA_Listview_DoubleClick:
  712.           case MUIA_Listview_DragType:
  713.           case MUIA_Listview_Input:
  714.           case MUIA_Listview_List:
  715.           case MUIA_Listview_MultiSelect:
  716.           case MUIA_Listview_ScrollerPos:
  717.           case MUIA_Listview_SelectChange:
  718. //|
  719.                set( data->lv, tag->ti_Tag, tag->ti_Data );
  720.                break;
  721.  
  722.           case MUIA_Popph_Array:
  723.                DoMethod( data->lv, MUIM_List_Insert, tag->ti_Data, -1, MUIV_List_Insert_Bottom );
  724.                break;
  725.  
  726.           case MUIA_Textinput_Contents:
  727.           case MUIA_String_Contents:
  728.           case MUIA_Popph_Contents:
  729.                set( data->str, MUIA_Popph_Contents, tag->ti_Data );
  730.                break;
  731.  
  732.           case MUIA_Popph_PopbuttonKey:
  733.                set( data->popbutton, MUIA_ControlChar, tag->ti_Data );
  734.                break;
  735.  
  736.           case MUIA_Popph_StringKey:
  737.                set( data->str, MUIA_ControlChar, tag->ti_Data );
  738.                break;
  739.  
  740.           case MUIA_Popph_Separator:
  741.                data->separator = tag->ti_Data;
  742.                break;
  743.  
  744.           case MUIA_Popph_CopyEntries:
  745.                data->copyentries = tag->ti_Data;
  746.  
  747.                if( tag->ti_Data )
  748.                    {
  749.                    // TRUE
  750.  
  751.                    set( data->lv, MUIA_List_ConstructHook, MUIV_List_ConstructHook_String );
  752.                    set( data->lv, MUIA_List_DestructHook , MUIV_List_DestructHook_String );
  753.                    }
  754.                else
  755.                    {
  756.                    set( data->lv, MUIA_List_ConstructHook, NULL );
  757.                    set( data->lv, MUIA_List_DestructHook , NULL );
  758.                    }
  759.                break;
  760.  
  761.           case MUIA_Popph_ReplaceMode:
  762.                data->replacemode = tag->ti_Data;
  763.                set( data->str, MUIA_Popph_ReplaceMode, tag->ti_Data );
  764.                break;
  765.  
  766.           case MUIA_Popph_PopCycleChain:
  767.                {
  768.                set( data->popbutton, MUIA_CycleChain, tag->ti_Data );
  769.                if( data->popaslbutton )
  770.                    set( data->popaslbutton, MUIA_CycleChain, tag->ti_Data );
  771.                }
  772.                break;
  773.  
  774.           case MUIA_Popph_Title:
  775.                {
  776.                set( data->lv, MUIA_List_Title, (tag->ti_Data > 0) ? TRUE : FALSE );
  777.  
  778.                data->title1[0] = 0;
  779.                data->title2[0] = 0;
  780.  
  781.                if( tag->ti_Data )
  782.                    {
  783.                    int keylen;
  784.                    char *zero;
  785.  
  786.                    zero = _strchr( (char *)tag->ti_Data, data->separator );
  787.  
  788.                    D(bug( "TitleSrc: '%s'\n", (char *)tag->ti_Data ));
  789.  
  790.  
  791.                    // is separator found
  792.                    if( zero )
  793.                        keylen = _strlen( (char *)tag->ti_Data, data->separator );
  794.                    else
  795.                        keylen = _strlen( (char *)tag->ti_Data, '\0' );
  796.  
  797.                    keylen = (keylen > POPPH_MAX_KEY_LEN) ? (POPPH_MAX_KEY_LEN - 1) : keylen ;
  798.  
  799.                    CopyMem( (APTR)tag->ti_Data, data->title1, keylen );
  800.                    data->title1[ keylen ] = 0;
  801.                    D(bug( "Title1: '%s' (%ld)\n", data->title1, _strlen( data->title1, '\0' ) ));
  802.  
  803.                    if( zero )
  804.                        {
  805.                        zero++;
  806.  
  807.                        keylen = _strlen( zero, '\0' );
  808.                        keylen = (keylen > POPPH_MAX_STRING_LEN) ? (POPPH_MAX_STRING_LEN - 1) : keylen ;
  809.  
  810.                        CopyMem( zero, data->title2, keylen );
  811.                        data->title2[ keylen ] = 0;
  812.                        D(bug( "Title2: '%s', (%ld)\n", data->title2, keylen ));
  813.                        }
  814.                    }
  815.                }
  816.                break;
  817.  
  818.           case MUIA_Popph_SingleColumn:
  819.                {
  820.                data->singlecolumn = tag->ti_Data;
  821.                set( data->lv, MUIA_List_Format, tag->ti_Data ? list_format_single : list_format_multi );
  822.                }
  823.                break;
  824.  
  825.           }
  826.        }
  827.  
  828.     return(DoSuperMethodA(cl, obj, msg));
  829. }
  830.  
  831. //|
  832. /// OM_GET
  833. static ULONG ASM _Get(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  834. {
  835. struct Data *data = INST_DATA(cl,obj);
  836. ULONG  *store = ((struct opGet *)msg)->opg_Storage;
  837.  
  838. //    D(bug(__NAME ": GET\n"));
  839.  
  840.     switch(((struct opGet *)msg)->opg_AttrID)
  841.        {
  842. ///      case MUIA_String_...:
  843.           case MUIA_String_Accept:
  844.           case MUIA_String_Acknowledge:
  845.           case MUIA_String_AdvanceOnCR:
  846.           case MUIA_String_AttachedList:
  847.           case MUIA_String_BufferPos:
  848.           case MUIA_String_DisplayPos:
  849.           case MUIA_String_EditHook:
  850.           case MUIA_String_Format:
  851.           case MUIA_String_Integer:
  852.           case MUIA_String_LonelyEditHook:
  853.           case MUIA_String_MaxLen:
  854.           case MUIA_String_Reject:
  855.           case MUIA_String_Secret:
  856. //|
  857. ///      case MUIA_Textinput_...:
  858.           case MUIA_Textinput_Multiline:
  859.           case MUIA_Textinput_MaxLen:
  860.           case MUIA_Textinput_MaxLines:
  861.           case MUIA_Textinput_AutoExpand:
  862.           case MUIA_Textinput_LeftOffset:
  863.           case MUIA_Textinput_TopOffset:
  864.           case MUIA_Textinput_TSCO:
  865.           case MUIA_Textinput_Blinkrate:
  866.           case MUIA_Textinput_Cursorstyle:
  867.           case MUIA_Textinput_AdvanceOnCR:
  868.           case MUIA_Textinput_TmpExtension:
  869.           case MUIA_Textinput_Quiet:
  870.           case MUIA_Textinput_Acknowledge:
  871.           case MUIA_Textinput_Integer:
  872.           case MUIA_Textinput_MinVersion:
  873.           case MUIA_Textinput_DefKeys:
  874.           case MUIA_Textinput_DefaultPopup:
  875.           case MUIA_Textinput_WordWrap:
  876.           case MUIA_Textinput_IsNumeric:
  877.           case MUIA_Textinput_MinVal:
  878.           case MUIA_Textinput_MaxVal:
  879.           case MUIA_Textinput_AcceptChars:
  880.           case MUIA_Textinput_RejectChars:
  881.           case MUIA_Textinput_Changed:
  882.           case MUIA_Textinput_AttachedList:
  883.           case MUIA_Textinput_RemainActive:
  884.           case MUIA_Textinput_CursorPos:
  885.           case MUIA_Textinput_Secret:
  886.           case MUIA_Textinput_Lines:
  887.           case MUIA_Textinput_Editable:
  888.           case MUIA_Textinputscroll_UseWinBorder:
  889.           case MUIA_Textinput_IsOld:
  890.           case MUIA_Textinput_MarkStart:
  891.           case MUIA_Textinput_MarkEnd:
  892.           case MUIA_Textinputscroll_VertScrollerOnly:
  893.           case MUIA_Textinput_NoInput:
  894.           case MUIA_Textinput_SetMin:
  895.           case MUIA_Textinput_SetMax:
  896.           case MUIA_Textinput_SetVMax:
  897.           case MUIA_Textinput_Styles:
  898.           case MUIA_Textinput_PreParse:
  899.           case MUIA_Textinput_Format:
  900.           case MUIA_Textinput_SetVMin:
  901.           case MUIA_Textinput_HandleURLHook:
  902.           case MUIA_Textinput_Tabs:
  903.           case MUIA_Textinput_TabLen:
  904.           case MUIA_Textinput_Bookmark1:
  905.           case MUIA_Textinput_Bookmark2:
  906.           case MUIA_Textinput_Bookmark3:
  907.           case MUIA_Textinput_CursorSize:
  908.           case MUIA_Textinput_TopLine:
  909. //|
  910. ///      case MUIA_BetterString_...:
  911.           case MUIA_BetterString_SelectSize:
  912.           case MUIA_BetterString_StayActive:
  913.           case MUIA_BetterString_Columns:
  914. //|
  915.        case MUIA_Popph_ContextMenu:
  916.        case MUIA_Popph_StringMaxLen:
  917.        case MUIA_Popph_StringType:
  918.             *store = xget( data->str, ((struct opGet *)msg)->opg_AttrID );
  919.             break;
  920.  
  921. ///         case MUIA_List_...:
  922.           case MUIA_List_Active:
  923.           case MUIA_List_AdjustHeight:
  924.           case MUIA_List_AdjustWidth:
  925.           case MUIA_List_AutoVisible:
  926.           case MUIA_List_CompareHook:
  927.           case MUIA_List_ConstructHook:
  928.           case MUIA_List_DestructHook:
  929.           case MUIA_List_DisplayHook:
  930.           case MUIA_List_DragSortable:
  931.           case MUIA_List_DropMark:
  932.           case MUIA_List_Entries:
  933.           case MUIA_List_First:
  934.           case MUIA_List_Format:
  935.           case MUIA_List_InsertPosition:
  936.           case MUIA_List_MinLineHeight:
  937.           case MUIA_List_MultiTestHook:
  938.           case MUIA_List_Pool:
  939.           case MUIA_List_PoolPuddleSize:
  940.           case MUIA_List_PoolThreshSize:
  941.           case MUIA_List_Quiet:
  942.           case MUIA_List_ShowDropMarks:
  943.           case MUIA_List_SourceArray:
  944.           case MUIA_List_Title:
  945.           case MUIA_List_Visible:
  946. //|
  947. ///         case MUIA_Listview_...:
  948.           case MUIA_Listview_ClickColumn:
  949.           case MUIA_Listview_DefClickColumn:
  950.           case MUIA_Listview_DoubleClick:
  951.           case MUIA_Listview_DragType:
  952.           case MUIA_Listview_Input:
  953.           case MUIA_Listview_List:
  954.           case MUIA_Listview_MultiSelect:
  955.           case MUIA_Listview_ScrollerPos:
  956.           case MUIA_Listview_SelectChange:
  957. //|
  958.                *store = xget( data->lv, ((struct opGet *)msg)->opg_AttrID );
  959.                break;
  960.  
  961.        case MUIA_Textinput_Contents:
  962.        case MUIA_String_Contents:
  963.        case MUIA_Popph_Contents:
  964. //            D(bug(__NAME "MUIA_Popph_Contents\n"));
  965.             *store = xget( data->str, MUIA_Popph_Contents );
  966.             return(TRUE);
  967.  
  968.        case MUIA_Popph_Separator:
  969. //            D(bug(__NAME "MUIA_Popph_Separator\n"));
  970.             *store = data->separator;
  971.             return(TRUE);
  972.  
  973.        case MUIA_Popph_CopyEntries:
  974. //            D(bug(__NAME "MUIA_Popph_CopyEntries\n"));
  975.             *store = data->copyentries;
  976.             return(TRUE);
  977.  
  978.        case MUIA_Popph_ReplaceMode:
  979.             *store = data->replacemode;
  980.             return(TRUE);
  981.  
  982.        case MUIA_Popasl_Active:
  983.        case MUIA_Popph_AslActive:
  984.             *store = data->asl_active;
  985.             return(TRUE);
  986.  
  987.        case MUIA_Popasl_Type:
  988.        case MUIA_Popph_AslType:
  989.             *store = data->asl_type;
  990.             return(TRUE);
  991.  
  992.        case MUIA_Version:
  993.             *store = (ULONG)VERSION;
  994.             break;
  995.  
  996.        case MUIA_Revision:
  997.             *store = (ULONG)REVISION;
  998.             break;
  999.  
  1000.        case MUIA_Popph_StringObject:
  1001.             *store = (ULONG)data->str;
  1002.             break;
  1003.  
  1004.        case MUIA_Popph_ListObject:
  1005.             *store = (ULONG)data->lv;
  1006.             break;                  
  1007.  
  1008.        case MUIA_Popph_PopCycleChain:
  1009.             *store = xget( data->popbutton, MUIA_CycleChain);
  1010.             break;
  1011.  
  1012.        case MUIA_Popph_SingleColumn:
  1013.             *store = data->singlecolumn;
  1014.             break;
  1015.        }
  1016.  
  1017.     return(DoSuperMethodA(cl, obj, msg));
  1018. }
  1019. //|
  1020.  
  1021. /// Dispatcher
  1022. ULONG ASM SAVEDS _Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  1023. {
  1024.  
  1025.     switch (msg->MethodID)
  1026.        {
  1027.        case OM_NEW    : return(_New     (cl, obj, (APTR)msg));
  1028.        case OM_DISPOSE: return(_Dispose (cl, obj, (APTR)msg));
  1029.        case OM_SET    : return(_Set     (cl, obj, (APTR)msg));
  1030.        case OM_GET    : return(_Get     (cl, obj, (APTR)msg));
  1031.  
  1032.        case MUIM_Popph_OpenAsl : return(_OpenAsl (cl, obj, (APTR)msg));
  1033.  
  1034. ///      case MUIM_List_...:
  1035.        case MUIM_List_Clear:
  1036.        case MUIM_List_CreateImage:
  1037.        case MUIM_List_DeleteImage:
  1038.        case MUIM_List_Exchange:
  1039.        case MUIM_List_GetEntry:
  1040.        case MUIM_List_Insert:
  1041.        case MUIM_List_InsertSingle:
  1042.        case MUIM_List_Jump:
  1043.        case MUIM_List_Move:
  1044.        case MUIM_List_NextSelected:
  1045.        case MUIM_List_Redraw:
  1046.        case MUIM_List_Remove:
  1047.        case MUIM_List_Select:
  1048.        case MUIM_List_Sort:
  1049.        case MUIM_List_TestPos:
  1050. //|
  1051.             {
  1052.             struct Data *data = INST_DATA(cl,obj);
  1053.  
  1054.             return(DoMethodA( data->lv, msg ));
  1055.             }
  1056.        }
  1057.  
  1058.     return((ULONG)DoSuperMethodA(cl, obj, msg));
  1059.  
  1060. }
  1061. //|
  1062.  
  1063.